package src.BlueBridge.GreedyStrategyAndDynamicProgramming;

import java.util.Arrays;
import java.util.Scanner;

/**
    有n项工作，每项工作分别在si时间开始，在ti时间结束
    对于每一项工作，你都可以选择参加与否，如果选择了参与，那么自始至终都必要全程参与
    此外，参与工作的时间段不能重复(即使是开始和结束的瞬间的重叠也是不允许的)
    你的目标是参与尽可能多的工作，那么最多能参与多少项工作呢
    输入:

    第一行:n
    第二行:n个整数空格隔开，代表n个工作的开始时间
    第三行:n个整数空格隔开，代表n个工作的结束时间

    样例输入:

    5
    1 2 4 6 8
    3 5 7 9 10

    样例输出:
    3

    说明:选取工作1 3 5

    思路:按照dfs的思想，每一个选或者不选

    思路:选择结束时间最早的，才能接到更多的活，按照结束时间来排序，如果终点相同的话，则也要对开始的时间排序

    也叫做不相交区间问题
 */

public class _3区间调度问题 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] s = new int[n];
        int[] t = new int[n];
        Job[] jobs = new Job[n];
        for (int i = 0 ; i < n ; i++) {
            s[i] = sc.nextInt();
        }
        for (int i = 0 ; i < n ; i++) {
            t[i] = sc.nextInt();
        }
        for (int i = 0 ; i < n ; i++) {
            jobs[i] = new Job(s[i], t[i]);
        }
        Arrays.sort(jobs);
        int res = f(n, jobs);
        System.out.println(res);
    }

    private static int f(int n, Job[] jobs) {
        int count = 1;
        // 第一个肯定是必选的，因为它是结束时间最早的
        int y = jobs[0].t;
        // 对于后面每一个任务
        for (int i = 0 ; i < n ; i++) {
            // 如果后面任务开始时间大于结束时间，直接选即可，因为是结束时间最早的
            if (jobs[i].s > y) {
                // 计数+1
                count++;
                // 把y更新一下
                y = jobs[i].t;
            }
        }
        return count;
    }

    /**
     * 必须实现排序规则
     */
    private static class Job implements Comparable<Job> {
        int s;
        int t;

        public Job(int s, int t) {
            this.s = s;
            this.t = t;
        }

        @Override
        public int compareTo(Job other) {
            int x = this.t - other.t;
            if (x == 0)
                return this.s - other.s;
            else
                return x;
        }
    }
}
